text:
{
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteFriend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteFriend",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteFriend(ctx, req.(*DeleteFriendRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_DeleteGroupUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteGroupUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteGroupUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteGroupUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteGroupUser(ctx, req.(*DeleteGroupUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_DeleteStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteStorage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteStorage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteStorage(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_DeleteStorageObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteStorageObjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteStorageObject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteStorageObject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteStorageObject(ctx, req.(*DeleteStorageObjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_DeleteUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteUsers(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_DeleteWalletLedger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteWalletLedgerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).DeleteWalletLedger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/DeleteWalletLedger",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).DeleteWalletLedger(ctx, req.(*DeleteWalletLedgerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_ExportAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).ExportAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/ExportAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).ExportAccount(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetAccount(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetConfig(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetFriends_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetFriends(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetFriends",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetFriends(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetGroups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetGroups",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetGroups(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetStatus(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_GetWalletLedger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).GetWalletLedger(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/GetWalletLedger",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).GetWalletLedger(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_ListStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).ListStorage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/ListStorage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).ListStorage(ctx, req.(*ListStorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_ListUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListUsersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).ListUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/ListUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).ListUsers(ctx, req.(*ListUsersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnbanUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnbanUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnbanUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnbanUser(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkCustom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkCustom(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkCustom",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkCustom(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnlinkDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkDevice(ctx, req.(*UnlinkDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkEmail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkEmail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkEmail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkEmail(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkFacebook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkFacebook(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkFacebook",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkFacebook(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkGameCenter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkGameCenter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkGameCenter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkGameCenter(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkGoogle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkGoogle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkGoogle",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkGoogle(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UnlinkSteam_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UnlinkSteam(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UnlinkSteam",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UnlinkSteam(ctx, req.(*AccountId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_UpdateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).UpdateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/UpdateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).UpdateAccount(ctx, req.(*UpdateAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Console_WriteStorageObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WriteStorageObjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConsoleServer).WriteStorageObject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/nakama.console.Console/WriteStorageObject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConsoleServer).WriteStorageObject(ctx, req.(*WriteStorageObjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Console_serviceDesc = grpc.ServiceDesc{
	ServiceName: "nakama.console.Console",
	HandlerType: (*ConsoleServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Authenticate",
			Handler:    _Console_Authenticate_Handler,
		},
		{
			MethodName: "BanUser",
			Handler:    _Console_BanUser_Handler,
		},
		{
			MethodName: "DeleteAccount",
			Handler:    _Console_DeleteAccount_Handler,
		},
		{
			MethodName: "DeleteFriend",
			Handler:    _Console_DeleteFriend_Handler,
		},
		{
			MethodName: "DeleteGroupUser",
			Handler:    _Console_DeleteGroupUser_Handler,
		},
		{
			MethodName: "DeleteStorage",
			Handler:    _Console_DeleteStorage_Handler,
		},
		{
			MethodName: "DeleteStorageObject",
			Handler:    _Console_DeleteStorageObject_Handler,
		},
		{
			MethodName: "DeleteUsers",
			Handler:    _Console_DeleteUsers_Handler,
		},
		{
			MethodName: "DeleteWalletLedger",
			Handler:    _Console_DeleteWalletLedger_Handler,
		},
		{
			MethodName: "ExportAccount",
			Handler:    _Console_ExportAccount_Handler,
		},
		{
			MethodName: "GetAccount",
			Handler:    _Console_GetAccount_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _Console_GetConfig_Handler,
		},
		{
			MethodName: "GetFriends",
			Handler:    _Console_GetFriends_Handler,
		},
		{
			MethodName: "GetGroups",
			Handler:    _Console_GetGroups_Handler,
		},
		{
			MethodName: "GetStatus",
			Handler:    _Console_GetStatus_Handler,
		},
		{
			MethodName: "GetWalletLedger",
			Handler:    _Console_GetWalletLedger_Handler,
		},
		{
			MethodName: "ListStorage",
			Handler:    _Console_ListStorage_Handler,
		},
		{
			MethodName: "ListUsers",
			Handler:    _Console_ListUsers_Handler,
		},
		{
			MethodName: "UnbanUser",
			Handler:    _Console_UnbanUser_Handler,
		},
		{
			MethodName: "UnlinkCustom",
			Handler:    _Console_UnlinkCustom_Handler,
		},
		{
			MethodName: "UnlinkDevice",
			Handler:    _Console_UnlinkDevice_Handler,
		},
		{
			MethodName: "UnlinkEmail",
			Handler:    _Console_UnlinkEmail_Handler,
		},
		{
			MethodName: "UnlinkFacebook",
			Handler:    _Console_UnlinkFacebook_Handler,
		},
		{
			MethodName: "UnlinkGameCenter",
			Handler:    _Console_UnlinkGameCenter_Handler,
		},
		{
			MethodName: "UnlinkGoogle",
			Handler:    _Console_UnlinkGoogle_Handler,
		},
		{
			MethodName: "UnlinkSteam",
			Handler:    _Console_UnlinkSteam_Handler,
		},
		{
			MethodName: "UpdateAccount",
			Handler:    _Console_UpdateAccount_Handler,
		},
		{
			MethodName: "WriteStorageObject",
			Handler:    _Console_WriteStorageObject_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "console/console.proto",
}

license_type: permissive

branch_name: refs/heads/master

extension: go


text:
// Copyright 2020 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package crostini

import (
	"bytes"
	"context"
	"io/ioutil"
	"os"
	"path/filepath"
	"time"

	"chromiumos/tast/local/vm"
	"chromiumos/tast/testing"
)

// PostTimeout is the standard time reserved for post-test tasks.
var PostTimeout = 30 * time.Second

// RunCrostiniPostTest runs hooks that should run after every test but before
// the precondition closes (if it's going to) e.g. collecting logs from the
// container.
func RunCrostiniPostTest(ctx context.Context, p PreData) {
	dir, ok := testing.ContextOutDir(ctx)
	if !ok || dir == "" {
		testing.ContextLog(ctx, "Failed to get name of directory")
		return
	}

	// If we haven't connected to chrome successfully, then the
	// test didn't get to do anything with the VM that could
	// possibly have generated logs, and even if it did we
	// couldn't access them, so bail out here.
	if p.Chrome == nil {
		testing.ContextLog(ctx, "Failed before connecting to chrome, no logs generated")
		return
	}

	// Container logs require a running VM and container. If one
	// hasn't been set, we can't fetch them.
	if p.Container != nil {
		trySaveContainerLogs(ctx, dir, p.Container)

		if err := p.Container.Cleanup(ctx, "."); err != nil {
			testing.ContextLog(ctx, "Failed to remove all files in home directory in the container: ", err)
		}
	} else {
		testing.ContextLog(ctx, "No active container, can't get journalctl logs")
	}

	// LXC logs only require a running VM, so even if the
	// container hasn't been set we can try to get a running VM
	// and use that.
	var machine *vm.VM
	if p.Container != nil {
		machine = p.Container.VM
	} else {
		machine2, err := vm.GetRunningVM(ctx, p.Chrome.NormalizedUser())
		machine = machine2
		if err != nil {
			testing.ContextLog(ctx, "Failed to get running VM, won't get LXC logs: ", err)
		}
	}
	if machine != nil {
		writeLXCLogs(ctx, dir, machine)
	}

	// VM logs are stored on the host, so we don't need the VM to
	// be running at all to get them.
	trySaveVMLogs(ctx, p.Post, dir, p.Chrome.NormalizedUser())
}

// When we run trySaveContainerLogs we only want to capture logs since we last
// ran i.e. from the test that just finished, not all logs since the start of
// the suite. Sadly, Debian's journalctl in stable is too old to support cursor
// files, so we have to parse a cursor out of the log stream and remember it
// between calls to trySaveContainerLogs.
var cursor string

// trySaveContainerLogs fetches new (i.e. since last time the function
// successfully ran) logs from the container and writes them to
// crostini_journalctl.txt
func trySaveContainerLogs(ctx context.Context, dir string, cont *vm.Container) {
	if cont == nil {
		testing.ContextLog(ctx, "No active container")
		return
	}
	args := []string{"sudo", "journalctl", "--no-pager", "--show-cursor"}
	if cursor != "" {
		args = append(args, "--cursor")
		args = append(args, cursor)
	}
	cmd := cont.Command(ctx, args...)
	output, err := cmd.Output()
	if err != nil {
		testing.ContextLog(ctx, "Error running journalctl: ", err)
		return
	}

	path := filepath.Join(dir, "crostini_journalctl.txt")
	err = ioutil.WriteFile(path, output, 0644)
	if err != nil {
		testing.ContextLog(ctx, "Error writing journalctl to log: ", err)
		return
	}

	cursorMarker := []byte("-- cursor: ")
	pos := bytes.LastIndex(output, cursorMarker)
	if pos == -1 {
		testing.ContextLog(ctx, "No journalctl cursor found")
		return
	}
	cursor = string(output[pos+len(cursorMarker):])
}

// trySaveVMLogs writes logs since the last call to the
// current test's output folder.
func trySaveVMLogs(ctx context.Context, post *PostTestData, dir, user string) {
	if post.vmLogReader == nil {
		logReader, err := vm.NewLogReaderForVM(ctx, vm.DefaultVMName, user)
		if err != nil {
			testing.ContextLog(ctx, "Error creating log reader: ", err)
			return
		}
		post.vmLogReader = logReader
	}
	if err := post.vmLogReader.TrySaveLogs(ctx, dir); err != nil {
		testing.ContextLog(ctx, "Error saving logs: ", err)
	}
}

func writeLXCLogs(ctx context.Context, dir string, machine *vm.VM) {
	testing.ContextLog(ctx, "Creating file")
	path := filepath.Join(dir, "crostini_logs.txt")
	f, err := os.Create(path)
	if err != nil {
		testing.ContextLog(ctx, "Error creating file: ", err)
		return
	}
	defer f.Close()

	f.WriteString("lxc info and lxc.log:\n")
	cmd := machine.Command(ctx, "sh", "-c", "LXD_DIR=/mnt/stateful/lxd LXD_CONF=/mnt/stateful/lxd_conf lxc info penguin --show-log")
	cmd.Stdout = f
	cmd.Stderr = f
	err = cmd.Run()
	if err != nil {
		testing.ContextLog(ctx, "Error getting lxc logs: ", err)
	}

	f.WriteString("\n\nconsole.log:\n")
	cmd = machine.Command(ctx, "sh", "-c", "LXD_DIR=/mnt/stateful/lxd  LXD_CONF=/mnt/stateful/lxd_conf lxc console penguin --show-log")
	cmd.Stdout = f
	cmd.Stderr = f
	err = cmd.Run()
	if err != nil {
		testing.ContextLog(ctx, "Error getting boot logs: ", err)
	}
}

branch_name: refs/heads/main


text:
# Copyright (C) 2016, STMicroelectronics - All Rights Reserved
# Released under the MIT license (see COPYING.MIT for the terms)

# Tools extracted from 96boards-tools https://github.com/96boards/96boards-tools
DESCRIPTION = "Tools for resizing the file system"
SECTION = "devel"

LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"

# e2fsprogs for resize2fs
RDEPENDS_${PN} += " e2fsprogs-resize2fs "

SRC_URI = " file://resize-helper file://target-system-init.service file://target-system-init file://target-system-init.sh.in"

S = "${WORKDIR}/git"

inherit systemd update-rc.d

SYSTEMD_PACKAGES += " target-system-init "
SYSTEMD_SERVICE_${PN} = "target-system-init.service"
SYSTEMD_AUTO_ENABLE_${PN} = "enable"

do_install() {
    install -d ${D}${systemd_unitdir}/system ${D}${base_sbindir}
    install -m 0644 ${WORKDIR}/target-system-init.service ${D}${systemd_unitdir}/system
    install -m 0755 ${WORKDIR}/target-system-init ${D}${base_sbindir}
    install -m 0755 ${WORKDIR}/resize-helper ${D}${base_sbindir}

    install -d ${D}${sysconfdir}/init.d
    install -m 0755 ${WORKDIR}/target-system-init.sh.in ${D}${sysconfdir}/init.d/target-system-init.sh

    sed -i -e "s:@sbindir@:${base_sbindir}:; s:@sysconfdir@:${sysconfdir}:" \
${D}${sysconfdir}/init.d/target-system-init.sh
}

INITSCRIPT_NAME = "target-system-init.sh"
INITSCRIPT_PARAMS = "start 22 5 3 ."

license: MIT

repository: Boldie/meta-exut

repo_name: Boldie/meta-exut

extension: bb


text:
package event

import (
	eerr "github.com/go-lego/engine/error"
)

// Dispatcher interface, used for dispatching event
type Dispatcher interface {
	// Dispatch event
	Dispatch(ent *Event)

	// AddResult add result
	AddResult(key, value string)

	// Result get result with key
	Result(key string) string

	// Results get all results
	Results() map[string]string

	// AddError add error
	AddError(e *eerr.Error)

	// HasError check if got an error
	HasError() bool

	// Error get single error by index
	Error(index int) *eerr.Error
}

repository: go-lego/engine

repo_name: go-lego/engine


text:
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
  "CXX"
  )
# The set of files for implicit dependencies of each language:
set(CMAKE_DEPENDS_CHECK_CXX
  "/home/andrea/MyKratos7.0/applications/FSIapplication/custom_python/add_convergence_accelerators_to_python.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/custom_python/add_convergence_accelerators_to_python.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/custom_python/add_custom_utilities_to_python.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/custom_python/add_custom_utilities_to_python.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/custom_python/add_mappers_to_python.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/custom_python/add_mappers_to_python.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/custom_python/fsi_python_application.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/custom_python/fsi_python_application.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/custom_utilities/AdvancedNMPointsMapper.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/custom_utilities/AdvancedNMPointsMapper.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/fsi_application.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/fsi_application.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/tests/cpp_tests/test_convergence_accelerators.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/tests/cpp_tests/test_convergence_accelerators.cpp.o"
  "/home/andrea/MyKratos7.0/applications/FSIapplication/tests/cpp_tests/test_partitioned_fsi_utilities.cpp" "/home/andrea/MyKratos7.0/cmake_build/applications/FSIapplication/CMakeFiles/KratosFSIApplication.dir/tests/cpp_tests/test_partitioned_fsi_utilities.cpp.o"
  )
set(CMAKE_CXX_COMPILER_ID "GNU")

# Preprocessor definitions for this target.
set(CMAKE_TARGET_DEFINITIONS_CXX
  "ADD_"
  "KRATOS_PYTHON"
  )

# The include file search paths:
set(CMAKE_CXX_TARGET_INCLUDE_PATH
  "applications/FSIapplication"
  "../applications/FSIapplication"
  "/home/andrea/boost_1_67_0"
  "../external_libraries/zlib"
  "external_libraries/zlib"
  "../external_libraries"
  "../kratos"
  "/usr/include/python3.6m"
  )

# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
  "/home/andrea/MyKratos7.0/cmake_build/kratos/CMakeFiles/KratosCore.dir/DependInfo.cmake"
  "/home/andrea/MyKratos7.0/cmake_build/external_libraries/gidpost/CMakeFiles/gidpost.dir/DependInfo.cmake"
  "/home/andrea/MyKratos7.0/cmake_build/external_libraries/zlib/CMakeFiles/zlib.dir/DependInfo.cmake"
  )

# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

extension: cmake


text:
package test

import (
	"github.com/pilosa/pilosa"
)

// Client represents a test wrapper for pilosa.Client.
type Client struct {
	*pilosa.Client
}

// MustNewClient returns a new instance of Client. Panic on error.
func MustNewClient(host string) *Client {
	c, err := pilosa.NewClient(host)
	if err != nil {
		panic(err)
	}
	return &Client{Client: c}
}

repository: codercom/pilosa

repo_name: codercom/pilosa


text:
SUMMARY = "Name Service Switch module for resolving the local hostname"
DESCRIPTION = "plugin for the GNU Name Service Switch (NSS) functionality of \
the GNU C Library (glibc) providing host name resolution for the locally \
configured system hostname as returned by gethostname(2)."
HOMEPAGE = "http://0pointer.de/lennart/projects/nss-myhostname/"
LICENSE = "LGPLv2.1"
LIC_FILES_CHKSUM = "file://LICENSE;md5=2d5025d4aa3495befef8f17206a5b0a1"

SRC_URI = "http://0pointer.de/lennart/projects/nss-myhostname/nss-myhostname-${PV}.tar.gz"

SRC_URI[md5sum] = "d4ab9ac36c053ab8fb836db1cbd4a48f"
SRC_URI[sha256sum] = "2ba744ea8d578d1c57c85884e94a3042ee17843a5294434d3a7f6c4d67e7caf2"

inherit autotools distro_features_check

# /etc/nsswitch.conf needs to be present
RDEPENDS:${PN} = "base-files"

# The systemd has its own copy of nss-myhostname
CONFLICT_DISTRO_FEATURES = "systemd"

pkg_postinst:${PN} () {
	sed -e '/^hosts:/s/\s*\<myhostname\>//' \
		-e 's/\(^hosts:.*\)\(\<files\>\)\(.*\)\(\<dns\>\)\(.*\)/\1\2 myhostname \3\4\5/' \
		-i $D${sysconfdir}/nsswitch.conf
}

pkg_prerm:${PN} () {
	sed -e '/^hosts:/s/\s*\<myhostname\>//' \
		-e '/^hosts:/s/\s*myhostname//' \
		-i $D${sysconfdir}/nsswitch.conf
}

repository: lgirdk/meta-linaro

repo_name: lgirdk/meta-linaro


text:
# Copyright 2014-2016, Corvusoft Ltd, All Rights Reserved.

find_path( kashmir_INCLUDE kashmir HINTS "${PROJECT_SOURCE_DIR}/dependency/kashmir" "/usr/include" "/usr/local/include" "/opt/local/include" )

if ( kashmir_INCLUDE )
    set( KASHMIR_FOUND TRUE )

    message( STATUS "${Green}Found Kashmir include at: ${kashmir_INCLUDE}${Reset}" )
else ( )
    message( FATAL_ERROR "${Red}Failed to locate Kashmir dependency.${Reset}" )
endif ( )

repository: X-CASH-official/X-CASH-Web-Wallet

repo_name: X-CASH-official/X-CASH-Web-Wallet

gha_license_id: NOASSERTION

gha_language: C


text:
SUMMARY = "Python TUN/TAP tunnel module"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=13f7629e8e4989b66b4a913ab05a91de"

SRC_URI[md5sum] = "adcaeea56d0ed06814487cdbde32d198"
SRC_URI[sha256sum] = "5ead86b3391acef239535ebcabeb04d2cdc6b40ab14580d28c6da193c2d1fe53"

PYPI_PACKAGE = "python-pytun"

inherit pypi setuptools3

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott

gha_license_id: MIT

gha_language: BitBake


text:
// Copyright 2016 The Cockroach Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.
//
// Author: Nathan VanBenschoten (nvanbenschoten@gmail.com)

package pgerror

import (
	"fmt"
	"io"

	"github.com/cockroachdb/cockroach/pkg/util/caller"
)

// pgError is an error that contains optional Postgres structured error
// fields. Implementations of the interface annotate these fields onto
// standard errors by wrapping them. The fields can then be retrieved from
// the errors using the functions like Hint and Detail below.
//
// See https://www.postgresql.org/docs/current/static/protocol-error-fields.html
// for a list of all Postgres error fields, most of which are optional and can
// be used to provide auxiliary error information.
//
// The style for the implementation is inspired by github.com/pkg/errors,
// and all pgError implementations are made to play nicely with that package.
// For instance, a pgError can be wrapped by errors.Wrap and its annotations
// can still be retrieved. pgErrors also implement the errors.causer interface,
// meaning that errors.Cause will work correctly with them.
type pgError interface {
	error
	causer

	// structured Postgres error fields. Each method attempts to return the
	// optional field and a boolean signifying if the optional field was
	// present.
	PGCode() (string, bool)
	Detail() (string, bool)
	Hint() (string, bool)
	SourceContext() (SrcCtx, bool)

	// formatting methods.
	fmt.Formatter
	verboseFormat() string
}

// from github.com/pkg/errors package.
type causer interface {
	Cause() error
}

var _ pgError = &withPGCode{}
var _ pgError = &withDetail{}
var _ pgError = &withHint{}
var _ pgError = &withSrcCtx{}

// pgErrorCause is embedded by each pgError implementation to eliminate
// method duplication.
type pgErrorCause struct {
	error
}

func (ec pgErrorCause) Cause() error                  { return ec.error }
func (ec pgErrorCause) PGCode() (string, bool)        { return PGCode(ec.error) }
func (ec pgErrorCause) Detail() (string, bool)        { return Detail(ec.error) }
func (ec pgErrorCause) Hint() (string, bool)          { return Hint(ec.error) }
func (ec pgErrorCause) SourceContext() (SrcCtx, bool) { return SourceContext(ec.error) }

// WithPGCode annotates err with a Postgres error code.
// If err is nil, WithPGCode returns nil.
func WithPGCode(err error, code string) error {
	if err == nil || code == "" {
		return err
	}
	return &withPGCode{
		pgErrorCause: pgErrorCause{err},
		code:         code,
	}
}

type withPGCode struct {
	pgErrorCause
	code string
}

func (w *withPGCode) PGCode() (string, bool)        { return w.code, true }
func (w *withPGCode) verboseFormat() string         { return "code: " + w.code }
func (w *withPGCode) Format(s fmt.State, verb rune) { formatPGError(w, s, verb) }

// WithDetail annotates err with a detail message.
// If err is nil, WithDetail returns nil.
func WithDetail(err error, detail string) error {
	if err == nil || detail == "" {
		return err
	}
	return &withDetail{
		pgErrorCause: pgErrorCause{err},
		detail:       detail,
	}
}

type withDetail struct {
	pgErrorCause
	detail string
}

func (w *withDetail) Detail() (string, bool)        { return w.detail, true }
func (w *withDetail) verboseFormat() string         { return "detail: " + w.detail }
func (w *withDetail) Format(s fmt.State, verb rune) { formatPGError(w, s, verb) }

// WithHint annotates err with a hint for users to resolve the
// issue in the future.
// If err is nil, WithHint returns nil.
func WithHint(err error, hint string) error {
	if err == nil || hint == "" {
		return err
	}
	return &withHint{
		pgErrorCause: pgErrorCause{err},
		hint:         hint,
	}
}

type withHint struct {
	pgErrorCause
	hint string
}

func (w *withHint) Hint() (string, bool)          { return w.hint, true }
func (w *withHint) verboseFormat() string         { return "hint: " + w.hint }
func (w *withHint) Format(s fmt.State, verb rune) { formatPGError(w, s, verb) }

// SrcCtx contains contextual information about the source of an error.
type SrcCtx struct {
	File     string
	Line     int
	Function string
}

// makeSrcCtx creates a SrcCtx value with contextual information about the
// caller at the requested depth.
func makeSrcCtx(depth int) SrcCtx {
	f, l, fun := caller.Lookup(depth + 1)
	return SrcCtx{File: f, Line: l, Function: fun}
}

// WithSourceContext annotates err with contextual information about the
// caller at the requested depth.
// If err is nil, WithSourceContext returns nil.
func WithSourceContext(err error, depth int) error {
	if err == nil {
		return nil
	}
	return &withSrcCtx{
		pgErrorCause: pgErrorCause{err},
		ctx:          makeSrcCtx(depth + 1),
	}
}

type withSrcCtx struct {
	pgErrorCause
	ctx SrcCtx
}

func (w *withSrcCtx) SourceContext() (SrcCtx, bool) { return w.ctx, true }
func (w *withSrcCtx) verboseFormat() string {
	return fmt.Sprintf("location: %s, %s:%d", w.ctx.Function, w.ctx.File, w.ctx.Line)
}
func (w *withSrcCtx) Format(s fmt.State, verb rune) { formatPGError(w, s, verb) }

// PGCode returns the Postgres error code of the error, if possible.
//
// If a code was never annotated onto the error, no code will be
// returned and a "found" flag will be returned as false.
func PGCode(err error) (string, bool) {
	if pgErr := unwrapToPGError(err); pgErr != nil {
		return pgErr.PGCode()
	}
	return "", false
}

// Detail returns the detail message of the error, if possible.
//
// If a detail was never annotated onto the error, no detail will
// be returned and a "found" flag will be returned as false.
func Detail(err error) (string, bool) {
	if pgErr := unwrapToPGError(err); pgErr != nil {
		return pgErr.Detail()
	}
	return "", false
}

// Hint returns the hint message of the error, if possible.
//
// If a hint was never annotated onto the error, no hint will be
// returned and a "found" flag will be returned as false.
func Hint(err error) (string, bool) {
	if pgErr := unwrapToPGError(err); pgErr != nil {
		return pgErr.Hint()
	}
	return "", false
}

// SourceContext returns contextual information about the source of
// an error, if possible.
//
// If contextual information was never annotated onto the error, no
// SrcCtx will be returned and a "found" flag will be returned as false.
func SourceContext(err error) (SrcCtx, bool) {
	if pgErr := unwrapToPGError(err); pgErr != nil {
		return pgErr.SourceContext()
	}
	return SrcCtx{}, false
}

// unwrapToPGError returns an unwrapped pgError annotation, if possible.
// The method behaves similarly to errors.Cause, but will only unwrap (call
// Cause on) non-pgError implementations. This allows us to strip errors
// added by errors.Wrap, and find the next pgError.
func unwrapToPGError(err error) pgError {
	for err != nil {
		if pgErr, ok := err.(pgError); ok {
			return pgErr
		}
		cause, ok := err.(causer)
		if !ok {
			break
		}
		err = cause.Cause()
	}
	return nil
}

func formatPGError(pgErr pgError, s fmt.State, verb rune) {
	switch verb {
	case 'v':
		if s.Flag('+') {
			fmt.Fprintf(s, "%+v\n%s", pgErr.Cause(), pgErr.verboseFormat())
			return
		}
		fallthrough
	case 's', 'q':
		if _, err := io.WriteString(s, pgErr.Error()); err != nil {
			panic(err)
		}
	}
}

repository: vaibhavarora/cockroach

repo_name: vaibhavarora/cockroach

gha_language: Go


text:
@Preamble{ " \newcommand{\noop}[1]{} " }

@inproceedings{gretsi,
  TITLE = {{Décomposition Non-négative de Dynamiques Géophysiques}},
  AUTHOR = {Lopez-Radcenco, M. and  Aissa-El-Bey, A. and  Tandéo, P and  Fablet, R.},
  ADDRESS = {Juan-Les-Pins, France},
  booktitle = {GRESTSI 2017: XXVIème colloque du GRETSI},
    year = {Forthcoming},
 }

@INPROCEEDINGS{SR_remote_sensing,
author={D. Yang and Z. Li and Y. Xia and Z. Chen},
booktitle={2015 IEEE International Conference on Digital Signal Processing (DSP)},
title={Remote sensing image super-resolution: Challenges and approaches},
year={2015},
pages={196-200},
keywords={frequency-domain analysis;geophysical image processing;image resolution;interpolation;learning (artificial intelligence);probability;remote sensing;complex atmospheric conditions;frequency domain based method;image processing;interpolation based method;learning based method;probability based method;remote sensing image superresolution;satellite imagery;Image reconstruction;Interpolation;Remote sensing;Signal resolution;Spatial resolution;Wavelet transforms;Super resolution;observation model;remote sensing},
doi={10.1109/ICDSP.2015.7251858},
ISSN={1546-1874},
month={July},}

@INPROCEEDINGS{redouane,
author={Lguensat, R. and Tandéo, P. and Ailliot, P. and Pulido M. and Fablet, R.},
booktitle={Monthly Weather Review},
title={The Analog Data Assimilation},
year={Submitted},
}

@article{analog,
author = { E. N.  Lorenz },
title = {Atmospheric Predictability as Revealed by Naturally Occurring Analogues},
journal = {Journal of the Atmospheric Sciences},
volume = {26},
number = {4},
pages = {636-646},
year = {1969},
doi = {10.1175/1520-0469(1969)26<636:APARBN>2.0.CO;2}

@conference {lorenz,
	title = {Predictability: a problem partly solved},
	booktitle = {Seminar on Predictability, 4-8 September 1995},
	volume = {1},
	year = {1995},
	pages = {1-18},
	publisher = {ECMWF},
	organization = {ECMWF},
	address = {Shinfield Park, Reading},
	author = {Lorenz, E.N.}
}

@inproceedings{icip,
  TITLE = {{Locally-adapted convolution-based super-resolution of irregularly-sampled ocean remote sensing data}},
  AUTHOR = {Lopez-Radcenco, M. and Fablet, R. and Aissa-El-Bey, A. and Ailliot, P.},
  ADDRESS = {Beijing, China},
  booktitle = {ICIP 2017: 2017 IEEE International Conference on Image Processing},
  year = {Forthcoming},%2017},
  %MONTH = {September},
 }

@inproceedings{fablet_igarss,
  TITLE = {{Learning multi-tracer convolutional models for the
reconstruction of high-resolution SSH fields}},
  AUTHOR = {Fablet, R. and Lopez-
  Radcenco, M. and Verron, J. and Mourre, B. and Chapron, B. and Pascual,  A.},
  ADDRESS = {Fort Worth, Texas, USA},
  booktitle = {IGARSS 2017: 2017 IEEE International Geoscience and Remote Sensing Symposium},
    year = {Forthcoming},%2017},
  %MONTH = {July},
 }

@unpublished{fablet_hal,
  TITLE = {{Improving mesoscale altimetric data from a multi-tracer convolutional processing of standard satellite-derived products}},
  AUTHOR = {Fablet, Ronan and Verron, Jacques and Mourre, Baptiste and Chapron, Bertrand and Pascual, Ananda},
  URL = {https://hal.archives-ouvertes.fr/hal-01365761},
  NOTE = {working paper or preprint},
  YEAR = {2016},
  MONTH = Oct,
  KEYWORDS = { Sea Surface Temperature ; convolutional models ;  super-resolution ;  OSSE ;  western Mediterranean Sea ; Sea Surface Height},
  PDF = {{https://hal.archives-ouvertes.fr/hal-01365761/file/improving-mesoscale-altimetric\%20\%2810\%29.pdf}},
  HAL_ID = {hal-01365761},
  HAL_VERSION = {v2},
}

@article{maze_pio,
title = "Coherent heat patterns revealed by unsupervised classification of Argo temperature profiles in the North Atlantic Ocean ",
journal = "Progress in Oceanography ",
volume = "151",
number = "",
pages = "275 - 292",
year = "2017",
note = "",
issn = "0079-6611",
doi = "https://doi.org/10.1016/j.pocean.2016.12.008",
url = "http://www.sciencedirect.com/science/article/pii/S0079661116300714",
author = "Guillaume Maze and Herlé Mercier and Ronan Fablet and Pierre Tandeo and Manuel Lopez-Radcenco and Philippe Lenca and Feucher, Ch.  and  Le Goff, C.",
keywords = "Heat content",
keywords = "Classification",
keywords = "North Atlantic",
keywords = "Stratification",
keywords = "Water mass",
keywords = "Thermocline",
keywords = "Argo",
keywords = "Pattern "
}

@inproceedings{maze_osd,
  TITLE = {Ocean Heat Content Structure Revealed by Un-Supervised Classification of Hydrographic Profiles},
  AUTHOR = {Maze, G. and Mercier, H. and Fablet, R. and Lenca, P. and Lopez Radcenco, M. and Tandeo, P. and Le Goff, C. and Feucher, Ch.},
  URL = {https://hal.archives-ouvertes.fr/hal-01345101},
  BOOKTITLE = {{OSD 2016: Ocean Sciences Meeting}},
  ADDRESS = {New Orleans, United States},
  HAL_LOCAL_REFERENCE = {17014},
  YEAR = {2016},
  MONTH = Feb,
  KEYWORDS = {Ocean heat ; Unsupervised classification ; Hydrographic Profiles},
  HAL_ID = {hal-01345101},
  HAL_VERSION = {v1},
}

@inproceedings{esann,
  TITLE = {{Non-negative decomposition of geophysical dynamics}},
  AUTHOR = {Lopez-Radcenco, M. and  Aissa-El-Bey, A. and  Tandéo, P and  Fablet, R.},
  ADDRESS = {Bruges, Belgium},
  booktitle = {ESANN’17: 25th Eur. Symp. on Artificial Neural Networks, Computational Intelligence and Machine Learning},
    year = {2017},
  MONTH = {April},
 }

@article{tandeo,
author={Tandeo, P. and Chapron, B. and Ba, S. and Autret, E. and Fablet, R.},
journal={Geoscience and Remote Sensing, IEEE Transactions on},
title={Segmentation of Mesoscale Ocean Surface Dynamics Using Satellite  {SST} and {SSH} Observations},
year={2014},
month={July},
volume={52},
number={7},
pages={4227-4235},
keywords={height measurement;ocean temperature;oceanographic techniques;regression analysis;sea level;SSH-SST spatiotemporal relationships;altimeter derived SSH;mesoscale ocean dynamics;mesoscale ocean surface dynamics segmentation;multisatellite measurements;novel latent class regression model;observation driven framework;ocean circulation;satellite SSH observations;satellite SST observations;sea surface height;sea surface temperature;upper ocean dynamics;Ocean temperature;Remote sensing;Sea surface;Spatiotemporal phenomena;Temperature measurement;Transfer functions;Altimetry;remote sensing;sea surface;statistics;temperature},
doi={10.1109/TGRS.2013.2280494},
ISSN={0196-2892},}

@misc{EM_notes,
  Author = {P. Smyth},
  Institution = {University of California},
  Howpublished = {University Lecture},
  Year = {2015},
  Title = {Finite Mixture Models and the EM Algorithm},
  url = {http://www.ics.uci.edu/~smyth/courses/cs274/notes/notes4.pdf}
}

@misc{ALS_notes,
  Author = {R. Zadeh and H. Li and B. He and M. Lublin and
Y. Perez},
  Institution = {Stanford University},
  Howpublished = {University Lecture},
  Year = {2015},
  Title = {CME 323: Distributed Algorithms and Optimization, Spring 2015},
  url = {http://stanford.edu/~rezab/dao/notes/lec14.pdf}
}

@ARTICLE{ALS_1,
   author = {{Hastie}, T. and {Mazumder}, R. and {Lee}, J. and {Zadeh}, R.
	},
    title = {Matrix Completion and Low-Rank SVD via Fast Alternating Least Squares},
  journal = {ArXiv e-prints},
archivePrefix = {arXiv},
   eprint = {1410.2596},
 primaryClass = {stat.ME},
 keywords = {Statistics - Methodology, Statistics - Machine Learning},
     year = {2014},
    month = {October},
   adsurl = {http://adsabs.harvard.edu/abs/2014arXiv1410.2596H},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@ARTICLE{ALS_2,
   author = {{Zachariah}, D. and {Sundin}, M. and {Jansson}, M. and {Chatterjee}, S.
	},
    title = {Alternating Least-Squares for Low-Rank Matrix Reconstruction},
  journal = {IEEE Signal Processing Letters},
archivePrefix = {arXiv},
   eprint = {1206.2493},
 primaryClass = {math.ST},
     year = {2012},
    month = {April},
   volume = {19},
    pages = {231-234},
      doi = {10.1109/LSP.2012.2188026},
   adsurl = {http://adsabs.harvard.edu/abs/2012ISPL...19..231Z},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@inproceedings{ALS_3,
 author = {G. Tak\'{a}cs and D. Tikk},
 title = {Alternating Least Squares for Personalized Ranking},
 booktitle = {Proceedings of the Sixth ACM Conference on Recommender Systems},
 series = {RecSys '12},
 year = {2012},
 isbn = {978-1-4503-1270-7},
 location = {Dublin, Ireland},
 pages = {83--90},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/2365952.2365972},
 doi = {10.1145/2365952.2365972},
 acmid = {2365972},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {alternating least squares, collaborative filtering, ranking},
}

@TechReport{EM_tutorial,
  author = 	 {J. Bilmes},
  title = 	 {A Gentle Tutorial of the {EM} algorithm and its application to Parameter Estimation for {G}aussian Mixture and Hidden {M}arkov Models},
  institution =  {ICSI},
  year = 	 {1997},
  number = 	 {TR-97-021},
  url = {http://melodi.ee.washington.edu/people/bilmes/mypubs/bilmes1997-em.pdf}
}

@TECHREPORT{EM_paper,
    author = {F. Dellaert},
    title = {The Expectation Maximization Algorithm},
    institution = {Georgia Institute of Technology},
    year = {2002},
    url = {http://www.cc.gatech.edu/~dellaert/em-paper.pdf}
}

@book{orthogonal,
  title={Mathematical Methods and Algorithms for Signal Processing},
  author={T.K. Moon and W.C. Stirling},
  isbn={9780201361865},
  lccn={99031038},
  url={https://books.google.fr/books?id=1xUfAQAAIAAJ},
  year={2000},
  publisher={Prentice Hall}
}

@article{shrink_1,
    author = {O. Ledoit and M. Wolf},
    citeulike-article-id = {13175241},
    citeulike-linkout-0 = {http://dx.doi.org/10.3905/jpm.2004.110},
    doi = {10.3905/jpm.2004.110},
    issn = {0095-4918},
    journal = {The Journal of Portfolio Management},
    month = jan,
    number = {4},
    pages = {110--119},
    posted-at = {2014-05-19 07:32:49},
    priority = {2},
    title = {{Honey, I Shrunk the Sample Covariance Matrix}},
    url = {http://dx.doi.org/10.3905/jpm.2004.110},
    volume = {30},
    year = {2004}
}

@article{shrink_2,
    author = {J. Schäfer and K. Strimmer},
    title = {A Shrinkage Approach to Large-Scale Covariance Matrix Estimation and Implications for Functional Genomics },
    year = {2005},
    journal = {Statistical Applications in Genetics and Molecular Biology, The Berkeley Electronic Press},
    url = {http://www.bepress.com/sagmb/vol4/iss1/art32/},
    volume = {4}
}

@article{OLS_1,
author = { W.R. Reed  and  H. Ye},
title = {Which panel data estimator should I use?},
journal = {Applied Economics},
volume = {43},
number = {8},
pages = {985-1000},
year = {2011},
doi = {10.1080/00036840802600087},

URL = {
        http://dx.doi.org/10.1080/00036840802600087

},
eprint = {
        http://dx.doi.org/10.1080/00036840802600087

}

}

@book{OLS_2,
  added-at = {2006-09-29T17:06:41.000+0200},
  address = {Cambridge and London},
  author = {, J.M. Wooldridge},
  biburl = {http://www.bibsonomy.org/bibtex/243450720ab17540e4fce3251239ec0e8/gerhard},
  file = {#F#},
  interhash = {7634506fe1e40831d09521e99547f88b},
  intrahash = {43450720ab17540e4fce3251239ec0e8},
  isbn = {0262232197},
  keywords = {Equation Econometrics Models Multiple/Simultaneous with Methods},
  publisher = {MIT Press},
  timestamp = {2006-09-29T17:06:41.000+0200},
  title = {Econometric analysis of cross section and panel data},
  year = 2002,
  chapter = 7
}

@ARTICLE{ozerov,
author={Ozerov, A. and Févotte, C.},
journal={Audio, Speech, and Language Processing, IEEE Transactions on},
title={Multichannel Nonnegative Matrix Factorization in Convolutive Mixtures for Audio Source Separation},
year={2010},
month={March},
volume={18},
number={3},
pages={550-563},
keywords={Fourier transforms;audio signal processing;blind source separation;convolution;matrix decomposition;speech processing;statistical analysis;Fourier transform;Itakura-Saito divergence;NMF methodology;blind separation;convolutive mixtures;decomposition algorithm;expectation-maximization algorithm;general data-driven object-based model;linear instantaneous mixing;multichannel audio data;multichannel data;multichannel nonnegative matrix factorization;multiplicative update algorithm;music sources;signal separation evaluation campaign;source signals;speech sources;statistical model;stereo audio source separation;superimposed Gaussian component;supervised separation;synthetic instantaneous mixtures;underdetermined convolutive mixture;Expectation-maximization (EM) algorithm;multichannel audio;nonnegative matrix factorization (NMF);nonnegative tensor factorization (NTF);underdetermined convolutive blind source separation (BSS)},
doi={10.1109/TASL.2009.2031510},
ISSN={1558-7916},}

@article{fevotte,
 author = {F{\'e}votte, C. and Bertin, N. and Durrieu, J.L.},
 title = {Nonnegative Matrix Factorization with the Itakura-saito Divergence: With Application to Music Analysis},
 journal = {Neural Comput.},
 issue_date = {March 2009},
 volume = {21},
 number = {3},
 month = mar,
 year = {2009},
 issn = {0899-7667},
 pages = {793--830},
 numpages = {38},
 url = {http://dx.doi.org/10.1162/neco.2008.04-08-771},
 doi = {10.1162/neco.2008.04-08-771},
 acmid = {1512591},
 publisher = {MIT Press},
 address = {Cambridge, MA, USA},
}

@incollection{sparse,
year={2005},
isbn={978-3-540-26208-4},
booktitle={Computational Intelligence and Bioinspired Systems},
volume={3512},
series={Lecture Notes in Computer Science},
editor={Cabestany, J. and Prieto, A. and Sandoval, F.},
doi={10.1007/11494669_31},
title={Extended Sparse Nonnegative Matrix Factorization},
url={http://dx.doi.org/10.1007/11494669_31},
publisher={Springer Berlin Heidelberg},
author={Stadlthanner, K. and Theis, F.J. and Puntonet, C.G. and Lang, E.W.},
pages={249-256},
language={English}
}

@INPROCEEDINGS{ICE_1,
author={Pieczynski, W.},
booktitle={Statistical Signal Processing, 2007. SSP '07. IEEE/SP 14th Workshop on},
title={Convergence of the Iterative Conditional Estimation and Application to Mixture Proportion Identification},
year={2007},
pages={49-53},
keywords={Computational modeling;Convergence;Ice;Image segmentation;Iterative methods;Parameter estimation;Random variables;Iterative conditional estimation;incomplete data;mixture estimation},
doi={10.1109/SSP.2007.4301216},
month={Aug},}

@INPROCEEDINGS{ICE_2,
    author = {O. Aliagnat and J.M. Boucher and D.C. He and W. Pieczynski and Universitc De Sherbrooke},
    title = {Hidden Markov Fields and Unsupervised Segmentation of Images},
    booktitle = {IAPR 11th International Conference on Pattern Recognition (ICPR 92)},
    year = {1992}
}

@INPROCEEDINGS{ICE_3,
    author = {W. Pieczynski},
    title = {Parameter estimation in the case of hidden data},
    booktitle = {Proceedings 16th Biennal Symposium on Communications, Kingston, Canada},
    year = {1992}
}

@MISC{ICE_4,
    author = {W. Pieczynski},
    title = {Champs de Markov cachés et estimation conditionnelle itérative},
    publisher = {GRETSI, Saint Martin d'Hères, France},
    url = {http://hdl.handle.net/2042/2458},
    year = {1994}
}

@inproceedings{kmeans_1,
    author = {Macqueen, J. B.},
    booktitle = {Procedings of the Fifth Berkeley Symposium on Math, Statistics, and Probability},
    citeulike-article-id = {176467},
    keywords = {clustering},
    pages = {281--297},
    posted-at = {2009-02-09 14:08:38},
    priority = {2},
    publisher = {University of California Press},
    title = {{Some Methods for classification and analysis of multivariate observations}},
    volume = {1},
    year = {1967}
}

@INPROCEEDINGS{kmeans_2,
author={S. Na and L. Xumin and G. Yong},
booktitle={Intelligent Information Technology and Security Informatics (IITSI), 2010 Third International Symposium on},
title={Research on k-means Clustering Algorithm: An Improved k-means Clustering Algorithm},
year={2010},
pages={63-67},
keywords={data mining;pattern clustering;cluster centers;clustering analysis method;data mining;data object;k-means clustering algorithm;Algorithm design and analysis;Clustering algorithms;Computational complexity;Data engineering;Data mining;Educational institutions;Information analysis;Iterative algorithms;Machine learning;Partitioning algorithms;clustering analysis;computational complexity;distance;k-means algorithm},
doi={10.1109/IITSI.2010.74},
month={April},}

@ARTICLE{kmeans_3,
author={Kanungo, T. and Mount, D.M. and Netanyahu, N.S. and Piatko, C.D. and Silverman, R. and Wu, A.Y.},
journal={Pattern Analysis and Machine Intelligence, IEEE Transactions on},
title={An efficient k-means clustering algorithm: analysis and implementation},
year={2002},
volume={24},
number={7},
pages={881-892},
keywords={covariance matrices;filtering theory;pattern clustering;Lloyd algorithm;color quantization;data compression;data structure;data-sensitive analysis;filtering algorithm;image segmentation;k-means clustering algorithm;kd-tree;mean squared distance;Algorithm design and analysis;Clustering algorithms;Data analysis;Data compression;Data mining;Data structures;Filtering algorithms;Iterative algorithms;Machine learning algorithms;Pattern recognition},
doi={10.1109/TPAMI.2002.1017616},
ISSN={0162-8828},
month={Jul},}

@article{kernel_1,
    author = {B. Schölkopf and A. Smola and E. Smola and K.R. Müller},
    title = {Nonlinear Component Analysis as a Kernel Eigenvalue Problem},
    journal = {Neural Computation},
    year = {1998},
    volume = {10},
    pages = {1299--1319}
}

@article{kernel_2,
  author    = {Q. Wang},
  title     = {Kernel Principal Component Analysis and its Applications in Face Recognition
               and Active Shape Models},
  journal   = {CoRR},
  volume    = {abs/1207.3538},
  year      = {2012},
  url       = {http://arxiv.org/abs/1207.3538},
  timestamp = {Wed, 10 Oct 2012 21:28:54 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/abs-1207-3538},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@article{latent,
year={1988},
issn={0176-4268},
journal={Journal of Classification},
volume={5},
number={2},
doi={10.1007/BF01897167},
title={A maximum likelihood methodology for clusterwise linear regression},
url={http://dx.doi.org/10.1007/BF01897167},
publisher={Springer-Verlag},
keywords={Cluster analysis; Multiple regression; Maximum likelihood estimation; E-M algorithm; Marketing trade shows},
author={DeSarbo, W.S. and Cron, W.L.},
pages={249-282},
language={English},
}

@article{parts,
	title = {Learning the parts of objects by non-negative matrix factorization},
	volume = {401},
	issn = {0028-0836},
	url = {http://dx.doi.org/10.1038/44565},
	doi = {10.1038/44565},
	number = {6755},
	journal = {Nature},
	author = {Lee, D.D. and Seung, H.S.},
	month = oct,
	year = {1999},
	pages = {788--791}
}

@ARTICLE{lasso,
    author = {R. Tibshirani},
    title = {Regression Shrinkage and Selection Via the Lasso},
    journal = {Journal of the Royal Statistical Society, Series B},
    year = {1994},
    volume = {58},
    pages = {267--288}
}

@article{Lapeyre,
        Author = {G. Lapeyre and P. Klein},
        Journal = {Journal of Physical Oceanography},
        Pages = {165--176},
        Title = {Dynamics of the Upper Oceanic Layers in Terms of Surface Quasigeostrophy Theory},
        Volume = {36},
        Year = {2006}}

@article{Klein,
        Author = {P. Klein and B. L. Hua and G. Lapeyre and X. Capet and S. {Le Gentil} and H. Sasaki},
        Journal = {Journal of Physical Oceanography},
        Pages = {1748--1763},
        Title = {Upper ocean turbulence from high {3-D} resolution simulations},
        Volume = {38},
        Year = {2008}}

@article{SST_SSH_1,
title = {The observed signature of mesoscale eddies in sea surface temperature and the associated heat transport},
journal = {Deep Sea Research Part I: Oceanographic Research Papers},
volume = {70},
pages = {60 - 72},
year = {2012},
issn = {0967-0637},
doi = {http://dx.doi.org/10.1016/j.dsr.2012.08.005},
url = {http://www.sciencedirect.com/science/article/pii/S0967063712001720},
author = {Ute Hausmann and Arnaud Czaja},
keywords = {Mesoscale},
keywords = {Sea surface temperature},
keywords = {Mixed-layer heat transport},
keywords = {Gulf Stream},
keywords = {Antarctic circumpolar current},
keywords = {Eddy-tracking}
}

@article {SST_SSH_2,
author = {Isern-Fontanet, Jordi and Lapeyre, Guillaume and Klein, Patrice and Chapron, Bertrand and Hecht, Matthew W.},
title = {Three-dimensional reconstruction of oceanic mesoscale currents from surface information},
journal = {Journal of Geophysical Research: Oceans},
volume = {113},
number = {C9},
issn = {2156-2202},
url = {http://dx.doi.org/10.1029/2007JC004692},
doi = {10.1029/2007JC004692},
pages = {n/a--n/a},
keywords = {Ocean observing systems, Instruments and techniques, Eddies and mesoscale processes, Upper ocean and mixed layer processes, Currents, Surface Quasi-Geostrophy, SST, 3D dynamics reconstruction},
year = {2008},
note = {C09005},
}

@article {SST_SSH_3,
author = {Klein, P. and Isern-Fontanet, J. and Lapeyre, G. and Roullet, G. and Danioux, E. and Chapron, B. and Le Gentil, S. and Sasaki, H.},
title = {Diagnosis of vertical velocities in the upper ocean from high resolution sea surface height},
journal = {Geophysical Research Letters},
volume = {36},
number = {12},
issn = {1944-8007},
url = {http://dx.doi.org/10.1029/2009GL038359},
doi = {10.1029/2009GL038359},
pages = {n/a--n/a},
keywords = {Ocean data assimilation and reanalysis, Eddies and mesoscale processes, Upper ocean and mixed layer processes, Internal and inertial waves, sea surface height, vertical velocity},
year = {2009},
note = {L12603},
}

@article {SST_SSH_4,
author = {LaCasce, J. H. and Mahadevan, A.},
title = {Estimating subsurface horizontal and vertical velocities from sea-surface temperature},
journal = {Journal of Marine Research},
volume = {64},
number = {5},
year = {2006-09-01T00:00:00},
pages = {695-721},
url = {http://www.ingentaconnect.com/content/jmr/jmr/2006/00000064/00000005/art00003},
doi = {doi:10.1357/002224006779367267}
}

@article {methods_1,
author = {Ali, M. M. and Swain, D. and Weller, R. A.},
title = {Estimation of ocean subsurface thermal structure from surface parameters: A neural network approach},
journal = {Geophysical Research Letters},
volume = {31},
number = {20},
issn = {1944-8007},
url = {http://dx.doi.org/10.1029/2004GL021192},
doi = {10.1029/2004GL021192},
pages = {n/a--n/a},
keywords = {Oceanic structures, Exploration Geophysics: Computational methods, potential fields, Oceanography: General: Ocean prediction, Upper ocean and mixed layer processes, Instruments and techniques},
year = {2004},
note = {L20308},
}

@Article{methods_2,
author={Chu, Peter C.
and Fan, Chenwu
and Liu, W. Timothy},
title={Determination of Vertical Thermal Structure from Sea Surface Temperature},
journal={Journal of Atmospheric and Oceanic Technology},
year={2000},
month={2016/01/21},
publisher={American Meteorological Society},
volume={17},
number={7},
pages={971-979},
issn={0739-0572},
doi={10.1175/1520-0426(2000)017<0971:DOVTSF>2.0.CO;2},
url={http://dx.doi.org/10.1175/1520-0426(2000)017<0971:DOVTSF>2.0.CO;2}
}

@Article{methods_3,
author={Wu, Xiangbai
and Yan, Xiao-Hai
and Jo, Young-Heon
and Liu, W. Timothy},
title={Estimation of Subsurface Temperature Anomaly in the North Atlantic Using a Self-Organizing Map Neural Network},
journal={Journal of Atmospheric and Oceanic Technology},
year={2012},
month={2016/01/21},
publisher={American Meteorological Society},
volume={29},
number={11},
pages={1675-1688},
issn={0739-0572},
doi={10.1175/JTECH-D-12-00013.1},
url={http://dx.doi.org/10.1175/JTECH-D-12-00013.1}
}

@Article{Held,
author = {Held,Isaac M. and Pierrehumbert,Raymond T. and Garner,Stephen T. and Swanson,Kyle L.},
title = {Surface quasi-geostrophic dynamics},
journal = {Journal of Fluid Mechanics},
volume = {282},
month = {1},
year = {1995},
issn = {1469-7645},
pages = {1--20},
numpages = {20},
doi = {10.1017/S0022112095000012},
URL = {http://journals.cambridge.org/article_S0022112095000012}
}

@article {casey,
author = {Casey, Kenneth S. and Adamec, David},
title = {Sea surface temperature and sea surface height variability in the North Pacific Ocean from 1993 to 1999},
journal = {Journal of Geophysical Research: Oceans},
volume = {107},
number = {C8},
issn = {2156-2202},
url = {http://dx.doi.org/10.1029/2001JC001060},
doi = {10.1029/2001JC001060},
pages = {14-1--14-12},
keywords = {Climate dynamics, Remote sensing, Climate and interannual variability, Oceanography: Physical: El Niño, sea surface temperature (SST), sea surface height (SSH), interannual variability, ENSO, TOPEX/Poseidon, AVHRR},
year = {2002},
}

@article {isern,
author = {Isern-Fontanet, J. and Chapron, B. and Lapeyre, G. and Klein, P.},
title = {Potential use of microwave sea surface temperatures for the estimation of ocean currents},
journal = {Geophysical Research Letters},
volume = {33},
number = {24},
issn = {1944-8007},
url = {http://dx.doi.org/10.1029/2006GL027801},
doi = {10.1029/2006GL027801},
pages = {n/a--n/a},
keywords = {Ocean observing systems, Remote sensing and electromagnetic processes, Currents, Eddies and mesoscale processes, Instruments and techniques, surface quasi-geostrophy, sea surface temperature, microwave radiometers},
year = {2006},
note = {L24608},
}

@Article{leuliette,
author={Leuliette, Eric W.
and Wahr, John M.},
title={Coupled Pattern Analysis of Sea Surface Temperature and {TOPEX/Poseidon} Sea Surface Height},
journal={Journal of Physical Oceanography},
year={1999},
month={2016/01/22},
publisher={American Meteorological Society},
volume={29},
number={4},
pages={599-611},
issn={0022-3670},
doi={10.1175/1520-0485(1999)029<0599:CPAOSS>2.0.CO;2},
url={http://dx.doi.org/10.1175/1520-0485(1999)029<0599:CPAOSS>2.0.CO;2}
}

@article {saraceno,
author = {Saraceno, Martin and Provost, Christine and Piola, Alberto R.},
title = {On the relationship between satellite-retrieved surface temperature fronts and chlorophyll a in the western South Atlantic},
journal = {Journal of Geophysical Research: Oceans},
volume = {110},
number = {C11},
issn = {2156-2202},
url = {http://dx.doi.org/10.1029/2004JC002736},
doi = {10.1029/2004JC002736},
pages = {n/a--n/a},
keywords = {Descriptive and regional oceanography, Diurnal, seasonal, and annual cycles, Remote sensing and electromagnetic processes, Fronts and jets, General circulation, fronts, chlorophyll, southwestern Atlantic},
year = {2005},
note = {C11016},
}

@article{Legoff,
title={Spatio-temporal decomposition of satellite-derived {SST}-{SSH} fields: links between surface data and ocean interior dynamics in the Aghulas region},
author ={ Le Goff, Clément and Tandéo, Pierre and Chapron, Bertrand and Fablet, Ronan},
journal={Selected Topics in Applied Earth Observations and Remote Sensing, IEEE Journal of},
year = {\noop{3002}Submitted},
}

@article{isern_fontanet,
Author = {Isern-Fontanet, J. and Shinde, {M.} and Gonz{\'a}lez-Haro, {C.}},
Journal =  {Journal of Physical Oceanography},
Owner = {cgonzalez},
Timestamp = {2013.01.07},
Title = {On the transfer function between surface fields and the geostrophic stream function in the {Mediterranean Sea}},
Volume = {44},
Pages={1406-1423},
doi={10.1175/JPO-D-13-0186.1},
Year = {2014}}

@ARTICLE{Cristina,
author = {Gonz{\'a}lez-Haro, C. and Isern-Fontanet, J.},
title = {Global ocean current reconstruction from altimetric and microwave {SST} measurements},
journal = {Journal of Geophysical Research: Oceans},
year = {2014},
volume = {119},
pages = {3378--3391},
number = {6},
doi = {10.1002/2013JC009728},
issn = {2169-9291},
keywords = {ocean currents, microwave SST, SQG theory, altimetry measurement, global ocean},
url = {http://dx.doi.org/10.1002/2013JC009728}
}

@incollection{proximal,
TITLE = {{Proximal Splitting Methods in Signal Processing}},
AUTHOR = {Combettes, Patrick Louis and Pesquet, Jean-Christophe},
URL = {https://hal.inria.fr/hal-00643807},
BOOKTITLE = {{Fixed-Point Algorithms for Inverse Problems in Science and Engineering}},
EDITOR = {Bauschke, H.H.; Burachik, R.S.; Combettes, P.L.; Elser, V.; Luke, D.R.; Wolkowicz, H. (Eds.)},
PUBLISHER = {{Springer}},
PAGES = {185-212},
YEAR = {2011},
DOI = {10.1007/978-1-4419-9569-8},
KEYWORDS = {sadco},
HAL_ID = {hal-00643807},
HAL_VERSION = {v1},
}

@article{tandeo,
author={Tandeo, P. and Chapron, B. and Ba, S. and Autret, E. and Fablet, R.},
journal={Geoscience and Remote Sensing, IEEE Transactions on},
title={Segmentation of Mesoscale Ocean Surface Dynamics Using Satellite SST and SSH Observations},
year={2014},
month={July},
volume={52},
number={7},
pages={4227-4235},
keywords={height measurement;ocean temperature;oceanographic techniques;regression analysis;sea level;SSH-SST spatiotemporal relationships;altimeter derived SSH;mesoscale ocean dynamics;mesoscale ocean surface dynamics segmentation;multisatellite measurements;novel latent class regression model;observation driven framework;ocean circulation;satellite SSH observations;satellite SST observations;sea surface height;sea surface temperature;upper ocean dynamics;Ocean temperature;Remote sensing;Sea surface;Spatiotemporal phenomena;Temperature measurement;Transfer functions;Altimetry;remote sensing;sea surface;statistics;temperature},
doi={10.1109/TGRS.2013.2280494},
ISSN={0196-2892},}

@misc{EM_notes,
  Author = {P. Smyth},
  Institution = {University of California},
  Howpublished = {University Lecture},
  Year = {2015},
  Title = {Finite Mixture Models and the EM Algorithm},
  url = {http://www.ics.uci.edu/~smyth/courses/cs274/notes/notes4.pdf}
}

@misc{ALS_notes,
  Author = {R. Zadeh and H. Li and B. He and M. Lublin and
Y. Perez},
  Institution = {Stanford University},
  Howpublished = {University Lecture},
  Year = {2015},
  Title = {CME 323: Distributed Algorithms and Optimization, Spring 2015},
  url = {http://stanford.edu/~rezab/dao/notes/lec14.pdf}
}

@ARTICLE{ALS_1,
   author = {{Hastie}, T. and {Mazumder}, R. and {Lee}, J. and {Zadeh}, R.
	},
    title = "{Matrix Completion and Low-Rank SVD via Fast Alternating Least Squares}",
  journal = {ArXiv e-prints},
archivePrefix = "arXiv",
   eprint = {1410.2596},
 primaryClass = "stat.ME",
 keywords = {Statistics - Methodology, Statistics - Machine Learning},
     year = 2014,
    month = oct,
   adsurl = {http://adsabs.harvard.edu/abs/2014arXiv1410.2596H},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@ARTICLE{ALS_2,
   author = {{Zachariah}, D. and {Sundin}, M. and {Jansson}, M. and {Chatterjee}, S.
	},
    title = "{Alternating Least-Squares for Low-Rank Matrix Reconstruction}",
  journal = {IEEE Signal Processing Letters},
archivePrefix = "arXiv",
   eprint = {1206.2493},
 primaryClass = "math.ST",
     year = 2012,
    month = apr,
   volume = 19,
    pages = {231-234},
      doi = {10.1109/LSP.2012.2188026},
   adsurl = {http://adsabs.harvard.edu/abs/2012ISPL...19..231Z},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

@inproceedings{ALS_3,
 author = {G. Tak\'{a}cs and D. Tikk},
 title = {Alternating Least Squares for Personalized Ranking},
 booktitle = {Proceedings of the Sixth ACM Conference on Recommender Systems},
 series = {RecSys '12},
 year = {2012},
 isbn = {978-1-4503-1270-7},
 location = {Dublin, Ireland},
 pages = {83--90},
 numpages = {8},
 url = {http://doi.acm.org/10.1145/2365952.2365972},
 doi = {10.1145/2365952.2365972},
 acmid = {2365972},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {alternating least squares, collaborative filtering, ranking},
}

@TechReport{EM_tutorial,
  author = 	 {J. Bilmes},
  title = 	 {A Gentle Tutorial of the {EM} algorithm and its application to Parameter Estimation for {G}aussian Mixture and Hidden {M}arkov Models},
  institution =  {ICSI},
  year = 	 {1997},
  number = 	 {TR-97-021},
  url = {http://melodi.ee.washington.edu/people/bilmes/mypubs/bilmes1997-em.pdf}
}

@TECHREPORT{EM_paper,
    author = {F. Dellaert},
    title = {The Expectation Maximization Algorithm},
    institution = {Georgia Institute of Technology},
    year = {2002},
    url = {http://www.cc.gatech.edu/~dellaert/em-paper.pdf}
}

@book{orthogonal,
  title={Mathematical Methods and Algorithms for Signal Processing},
  author={T.K. Moon and W.C. Stirling},
  isbn={9780201361865},
  lccn={99031038},
  url={https://books.google.fr/books?id=1xUfAQAAIAAJ},
  year={2000},
  publisher={Prentice Hall}
}

@article{shrink_1,
    author = {O. Ledoit and M. Wolf},
    citeulike-article-id = {13175241},
    citeulike-linkout-0 = {http://dx.doi.org/10.3905/jpm.2004.110},
    doi = {10.3905/jpm.2004.110},
    issn = {0095-4918},
    journal = {The Journal of Portfolio Management},
    month = jan,
    number = {4},
    pages = {110--119},
    posted-at = {2014-05-19 07:32:49},
    priority = {2},
    title = {{Honey, I Shrunk the Sample Covariance Matrix}},
    url = {http://dx.doi.org/10.3905/jpm.2004.110},
    volume = {30},
    year = {2004}
}

@article{shrink_2,
    author = {J. Schäfer and K. Strimmer},
    title = {A Shrinkage Approach to Large-Scale Covariance Matrix Estimation and Implications for Functional Genomics },
    year = {2005},
    journal = {Statistical Applications in Genetics and Molecular Biology, The Berkeley Electronic Press},
    url = {http://www.bepress.com/sagmb/vol4/iss1/art32/},
    volume = {4}
}

@article{OLS_1,
author = { W.R. Reed  and  H. Ye},
title = {Which panel data estimator should I use?},
journal = {Applied Economics},
volume = {43},
number = {8},
pages = {985-1000},
year = {2011},
doi = {10.1080/00036840802600087},

URL = {
        http://dx.doi.org/10.1080/00036840802600087

},
eprint = {
        http://dx.doi.org/10.1080/00036840802600087

}

}

@book{OLS_2,
  added-at = {2006-09-29T17:06:41.000+0200},
  address = {Cambridge and London},
  author = {, J.M. Wooldridge},
  biburl = {http://www.bibsonomy.org/bibtex/243450720ab17540e4fce3251239ec0e8/gerhard},
  file = {#F#},
  interhash = {7634506fe1e40831d09521e99547f88b},
  intrahash = {43450720ab17540e4fce3251239ec0e8},
  isbn = {0262232197},
  keywords = {Equation Econometrics Models Multiple/Simultaneous with Methods},
  publisher = {MIT Press},
  timestamp = {2006-09-29T17:06:41.000+0200},
  title = {Econometric analysis of cross section and panel data},
  year = 2002,
  chapter = 7
}

@ARTICLE{ozerov,
author={Ozerov, A. and Févotte, C.},
journal={Audio, Speech, and Language Processing, IEEE Transactions on},
title={Multichannel Nonnegative Matrix Factorization in Convolutive Mixtures for Audio Source Separation},
year={2010},
month={March},
volume={18},
number={3},
pages={550-563},
keywords={Fourier transforms;audio signal processing;blind source separation;convolution;matrix decomposition;speech processing;statistical analysis;Fourier transform;Itakura-Saito divergence;NMF methodology;blind separation;convolutive mixtures;decomposition algorithm;expectation-maximization algorithm;general data-driven object-based model;linear instantaneous mixing;multichannel audio data;multichannel data;multichannel nonnegative matrix factorization;multiplicative update algorithm;music sources;signal separation evaluation campaign;source signals;speech sources;statistical model;stereo audio source separation;superimposed Gaussian component;supervised separation;synthetic instantaneous mixtures;underdetermined convolutive mixture;Expectation-maximization (EM) algorithm;multichannel audio;nonnegative matrix factorization (NMF);nonnegative tensor factorization (NTF);underdetermined convolutive blind source separation (BSS)},
doi={10.1109/TASL.2009.2031510},
ISSN={1558-7916},}

@article{fevotte,
 author = {F{\'e}votte, C. and Bertin, N. and Durrieu, J.L.},
 title = {Nonnegative Matrix Factorization with the Itakura-saito Divergence: With Application to Music Analysis},
 journal = {Neural Comput.},
 issue_date = {March 2009},
 volume = {21},
 number = {3},
 month = mar,
 year = {2009},
 issn = {0899-7667},
 pages = {793--830},
 numpages = {38},
 url = {http://dx.doi.org/10.1162/neco.2008.04-08-771},
 doi = {10.1162/neco.2008.04-08-771},
 acmid = {1512591},
 publisher = {MIT Press},
 address = {Cambridge, MA, USA},
}

@incollection{sparse,
year={2005},
isbn={978-3-540-26208-4},
booktitle={Computational Intelligence and Bioinspired Systems},
volume={3512},
series={Lecture Notes in Computer Science},
editor={Cabestany, J. and Prieto, A. and Sandoval, F.},
doi={10.1007/11494669_31},
title={Extended Sparse Nonnegative Matrix Factorization},
url={http://dx.doi.org/10.1007/11494669_31},
publisher={Springer Berlin Heidelberg},
author={Stadlthanner, K. and Theis, F.J. and Puntonet, C.G. and Lang, E.W.},
pages={249-256},
language={English}
}

@INPROCEEDINGS{ICE_1,
author={Pieczynski, W.},
booktitle={Statistical Signal Processing, 2007. SSP '07. IEEE/SP 14th Workshop on},
title={Convergence of the Iterative Conditional Estimation and Application to Mixture Proportion Identification},
year={2007},
pages={49-53},
keywords={Computational modeling;Convergence;Ice;Image segmentation;Iterative methods;Parameter estimation;Random variables;Iterative conditional estimation;incomplete data;mixture estimation},
doi={10.1109/SSP.2007.4301216},
month={Aug},}

@INPROCEEDINGS{ICE_2,
    author = {O. Aliagnat and J.M. Boucher and D.C. He and W. Pieczynski and Universitc De Sherbrooke},
    title = {Hidden Markov Fields and Unsupervised Segmentation of Images},
    booktitle = {IAPR 11th International Conference on Pattern Recognition (ICPR 92)},
    year = {1992}
}

@INPROCEEDINGS{ICE_3,
    author = {W. Pieczynski},
    title = {Parameter estimation in the case of hidden data},
    booktitle = {"Proceedings 16th Biennal Symposium on Communications", Kingston, Canada},
    year = {1992}
}

@MISC{ICE_4,
    author = {W. Pieczynski},
    title = {Champs de Markov cachés et estimation conditionnelle itérative},
    publisher = {GRETSI, Saint Martin d'Hères, France},
    url = {http://hdl.handle.net/2042/2458},
    year = {1994}
}

@inproceedings{kmeans_1,
    author = {Macqueen, J. B.},
    booktitle = {Procedings of the Fifth Berkeley Symposium on Math, Statistics, and Probability},
    citeulike-article-id = {176467},
    keywords = {clustering},
    pages = {281--297},
    posted-at = {2009-02-09 14:08:38},
    priority = {2},
    publisher = {University of California Press},
    title = {{Some Methods for classification and analysis of multivariate observations}},
    volume = {1},
    year = {1967}
}

@INPROCEEDINGS{kmeans_2,
author={S. Na and L. Xumin and G. Yong},
booktitle={Intelligent Information Technology and Security Informatics (IITSI), 2010 Third International Symposium on},
title={Research on k-means Clustering Algorithm: An Improved k-means Clustering Algorithm},
year={2010},
pages={63-67},
keywords={data mining;pattern clustering;cluster centers;clustering analysis method;data mining;data object;k-means clustering algorithm;Algorithm design and analysis;Clustering algorithms;Computational complexity;Data engineering;Data mining;Educational institutions;Information analysis;Iterative algorithms;Machine learning;Partitioning algorithms;clustering analysis;computational complexity;distance;k-means algorithm},
doi={10.1109/IITSI.2010.74},
month={April},}

@ARTICLE{kmeans_3,
author={Kanungo, T. and Mount, D.M. and Netanyahu, N.S. and Piatko, C.D. and Silverman, R. and Wu, A.Y.},
journal={Pattern Analysis and Machine Intelligence, IEEE Transactions on},
title={An efficient k-means clustering algorithm: analysis and implementation},
year={2002},
volume={24},
number={7},
pages={881-892},
keywords={covariance matrices;filtering theory;pattern clustering;Lloyd algorithm;color quantization;data compression;data structure;data-sensitive analysis;filtering algorithm;image segmentation;k-means clustering algorithm;kd-tree;mean squared distance;Algorithm design and analysis;Clustering algorithms;Data analysis;Data compression;Data mining;Data structures;Filtering algorithms;Iterative algorithms;Machine learning algorithms;Pattern recognition},
doi={10.1109/TPAMI.2002.1017616},
ISSN={0162-8828},
month={Jul},}

@article{kernel_1,
    author = {B. Schölkopf and A. Smola and E. Smola and K.R. Müller},
    title = {Nonlinear Component Analysis as a Kernel Eigenvalue Problem},
    journal = {Neural Computation},
    year = {1998},
    volume = {10},
    pages = {1299--1319}
}

@article{kernel_2,
  author    = {Q. Wang},
  title     = {Kernel Principal Component Analysis and its Applications in Face Recognition
               and Active Shape Models},
  journal   = {CoRR},
  volume    = {abs/1207.3538},
  year      = {2012},
  url       = {http://arxiv.org/abs/1207.3538},
  timestamp = {Wed, 10 Oct 2012 21:28:54 +0200},
  biburl    = {http://dblp.uni-trier.de/rec/bib/journals/corr/abs-1207-3538},
  bibsource = {dblp computer science bibliography, http://dblp.org}
}

@ARTICLE{MIMO_1,
author={Abed-Meraim, K. and Loubaton, P. and Moulines, E.},
journal={Information Theory, IEEE Transactions on},
title={A subspace algorithm for certain blind identification problems},
year={1997},
volume={43},
number={2},
pages={499-511},
keywords={FIR filters;covariance matrices;filtering theory;identification;moving average processes;transfer functions;FIR transfer functions;MA model estimations;asymptotic covariance;asymptotic performance analysis;blind identification problems;covariance matrix;estimation method;multichannel FIR filters;noise subspace;numerical simulations;output signals;rational subspaces;subspace algorithm;subspace identification methods;transfer function;Additive white noise;Covariance matrix;Finite impulse response filter;Numerical simulation;Performance analysis;Polynomials;Signal processing;Signal to noise ratio;System identification;Transfer functions},
doi={10.1109/18.556108},
ISSN={0018-9448},
month={Mar},}

@ARTICLE{MIMO_2,
author={Eidinger, E. and Yeredor, A.},
journal={Signal Processing, IEEE Transactions on},
title={Blind MIMO identification using the second characteristic function},
year={2005},
volume={53},
number={11},
pages={4067-4079},
keywords={Hessian matrices;MIMO systems;blind source separation;deconvolution;frequency estimation;frequency response;higher order statistics;Hessian matrix;blind MIMO identification;convolutive blind source separation;deconvolution;frequency response matrix;high-order statistics;joint diagonalization;multiinput-multioutput system;permutation ambiguity;phase ambiguity;polyspectra;second characteristic function;signal-to-noise ratio;time-lagged joint cumulant;Frequency estimation;Frequency response;MIMO;Matrices;Phase estimation;Signal resolution;Signal to noise ratio;Stability;Statistics;Yield estimation;Blind MIMO Deconvolution;blind MIMO identification;characteristic function;convolutive blind source separation;joint diagonalization;permutation ambiguity;phase ambiguity},
doi={10.1109/TSP.2005.857022},
ISSN={1053-587X},
month={Nov},}

@article{latent,
year={1988},
issn={0176-4268},
journal={Journal of Classification},
volume={5},
number={2},
doi={10.1007/BF01897167},
title={A maximum likelihood methodology for clusterwise linear regression},
url={http://dx.doi.org/10.1007/BF01897167},
publisher={Springer-Verlag},
keywords={Cluster analysis; Multiple regression; Maximum likelihood estimation; E-M algorithm; Marketing trade shows},
author={DeSarbo, W.S. and Cron, W.L.},
pages={249-282},
language={English},
}

@article{parts,
	title = {Learning the parts of objects by non-negative matrix factorization},
	volume = {401},
	issn = {0028-0836},
	url = {http://dx.doi.org/10.1038/44565},
	doi = {10.1038/44565},
	number = {6755},
	journal = {Nature},
	author = {Lee, D.D. and Seung, H.S.},
	month = oct,
	year = {1999},
	pages = {788--791}
}

@ARTICLE{lasso,
    author = {R. Tibshirani},
    title = {Regression Shrinkage and Selection Via the Lasso},
    journal = {Journal of the Royal Statistical Society, Series B},
    year = {1994},
    volume = {58},
    pages = {267--288}
}

@INPROCEEDINGS{multi,
author={Burr, A.G.},
booktitle={Multipath Countermeasures, IEE Colloquium on},
title={The multipath problem: an overview},
year={1996},
pages={1/1-1/7},
keywords={channel coding;fading;forward error correction;interference suppression;multipath channels;optical communication;radiofrequency interference;FEC coding;dispersion;fading;multipath;narrow-band system;wide band system},
doi={10.1049/ic:19960754},
month={May},}

@INPROCEEDINGS{BSS,
author={Pal, M. and Roy, R. and Basu, J. and Bepari, M.S.},
booktitle={Oriental COCOSDA held jointly with 2013 Conference on Asian Spoken Language Research and Evaluation (O-COCOSDA/CASLRE), 2013 International Conference},
title={Blind source separation: A review and analysis},
year={2013},
pages={1-5},
keywords={blind source separation;independent component analysis;ICA;blind source separation;independent component analysis;Blind source separation;Microphones;Signal processing algorithms;Speech;Speech recognition;Blind Source Separation;De-mixing;Independent Component Analysis;Mixing},
doi={10.1109/ICSDA.2013.6709849},
month={Nov},}

@MISC{Lapeyre,
    author = {G. Lapeyre and P. Klein},
    title = {Dynamics of the Upper Oceanic Layers in Terms of Surface Quasigeostrophy Theory},
    year = {2006}
}

@MISC{Klein,
    author = {P. Klein and B.L. Hua and G. Lapeyre and others},
    title = { Upper Ocean Turbulence from High-Resolution 3D Simulations},
    year = {2008}
}

@inproceedings{NNLD,
author = {Lopez-Radcenco, M. and Aissa-El-Bey, A. and Ailliot, P. and Fablet, R. and Tandeo, P.},
title = {{Non-negative decomposition of linear relationships: application to multi-source ocean remote sensing data}},
booktitle = {ICASSP 2016: 41st IEEE International Conference on Acoustics, Speech and Signal Processing},
year = {2016},
pages = {4179-4183}
}

@ARTICLE{jstars,
author={López-Radcenco, Manuel and Aïssa-El-Bey, Abdeldjalil and Ailliot, Pierre and  Tandéo, Pierre and Chapron, Bertrand and Fablet, Ronan},
title={Non-negative Multi-modal Decomposition of Sea Surface Dynamics from Satellite-derived {SST-SSH} Data},
journal={},
year={\noop{ } In preparation},
}

@incollection{ L96_2, author = "Edward N. Lorenz", editor = "Tim Palmer and Renate Hagedorn", title = {Predictability – a problem partly solved}, booktitle = {Predictability of Weather and Climate}, publisher = {Cambridge University Press}, year = {2006}, pages = {40--58}, isbn = {9780511617652}, note = {Cambridge Books Online}, url = {http://dx.doi.org/10.1017/CBO9780511617652.004} }

@article{L96_1,
   author = "Karimi, A. and Paul, M. R.",
   title = "Extensive chaos in the Lorenz-96 model",
   journal = "Chaos",
   year = "2010",
   volume = "20",
   number = "4",
   eid = 043105,
   pages = "",
   url = "http://scitation.aip.org/content/aip/journal/chaos/20/4/10.1063/1.3496397",
   doi = "http://dx.doi.org/10.1063/1.3496397"
}

@article{armijo,
author = "Armijo, Larry",
fjournal = "Pacific Journal of Mathematics",
journal = "Pacific J. Math.",
number = "1",
pages = "1--3",
publisher = "Pacific Journal of Mathematics, A Non-profit Corporation",
title = "Minimization of functions having Lipschitz continuous first partial derivatives.",
url = "http://projecteuclid.org/euclid.pjm/1102995080",
volume = "16",
year = "1966"
}

@article{Moreau1965,
author = {Moreau, J.J.},
journal = {Bulletin de la Société Mathématique de France},
keywords = {functional analysis},
language = {fre},
pages = {273-299},
publisher = {Société mathématique de France},
title = {Proximité et dualité dans un espace hilbertien},
url = {http://eudml.org/doc/87067},
volume = {93},
year = {1965},
}

@misc{prox,
  Author = {Yao-Liang Yu},
  Institution = {Machine Learning Departement, Carnegie Melon University},
  Howpublished = {University Lecture},
  Year = {2014},
  Title = {The Proximity Operator},
  url = {http://www.cs.cmu.edu/~yaoliang/mynotes/po.pdf}
}

@ARTICLE{aharon,
author={M. Aharon and M. Elad and A. Bruckstein},
journal={IEEE Transactions on Signal Processing},
title={\rm K -SVD: An Algorithm for Designing Overcomplete Dictionaries for Sparse Representation},
year={2006},
volume={54},
number={11},
pages={4311-4322},
keywords={image coding;image representation;iterative methods;singular value decomposition;transforms;K-SVD;K-means clustering process;image data;iterative method;linear transforms;overcomplete dictionary;signals sparse representation;sparse coding;sparsity constraints;Algorithm design and analysis;Clustering algorithms;Dictionaries;Feature extraction;Inverse problems;Iterative algorithms;Matching pursuit algorithms;Prototypes;Pursuit algorithms;Signal design;Atom decomposition;FOCUSS;basis pursuit;codebook;dictionary;gain-shape VQ;matching pursuit;sparse representation;training;vector quantization},
doi={10.1109/TSP.2006.881199},
ISSN={1053-587X},
month={Nov},}

@MISC{Rubinstein,
    author = {Ron Rubinstein and Michael Zibulevsky and Michael Elad},
    title = {Efficient Implementation of the K-SVD Algorithm using Batch Orthogonal Matching Pursuit},
    year = {}
}

@INPROCEEDINGS{nnksvd,
    author = {Michal Aharon and Michael Elad and Alfred M. Bruckstein},
    title = {K-SVD and its non-negative variant for dictionary design},
    booktitle = {Proceedings of the SPIE conference wavelets},
    year = {2005},
    pages = {327--339}
}

@ARTICLE{double_sparse,
author={R. Rubinstein and M. Zibulevsky and M. Elad},
journal={IEEE Transactions on Signal Processing},
title={Double Sparsity: Learning Sparse Dictionaries for Sparse Signal Approximation},
year={2010},
volume={58},
number={3},
pages={1553-1564},
keywords={image coding;image denoising;sparse matrices;3D image denoising;computed tomography;double sparsity;learning sparse dictionaries;signal representation;sparse coding;sparse signal approximation;Computed tomography;K-SVD;dictionary learning;signal denoising;sparse coding;sparse representation},
doi={10.1109/TSP.2009.2036477},
ISSN={1053-587X},
month={March},}

@ARTICLE{aksvd,
author={R. Rubinstein and T. Peleg and M. Elad},
journal={IEEE Transactions on Signal Processing},
title={Analysis K-SVD: A Dictionary-Learning Algorithm for the Analysis Sparse Model},
year={2013},
volume={61},
number={3},
pages={661-677},
keywords={dictionaries;greedy algorithms;learning (artificial intelligence);optimisation;signal representation;signal synthesis;singular value decomposition;K-SVD analysis;analysis sparse model;dictionary-learning algorithm;linear combination decomposition;optimized backward greedy algorithm;signals representation;synthesis-based sparse representation model;tailored pursuit algorithm;Algorithm design and analysis;Analytical models;Dictionaries;Mathematical model;Noise measurement;Noise reduction;Vectors;Analysis Model;Backward Greedy (BG) Pursuit;K-SVD;dictionary learning;image denosing;optimized backward greedy pursuit (OBG);sparse representations;synthesis model},
doi={10.1109/TSP.2012.2226445},
ISSN={1053-587X},
month={Feb},}

@ARTICLE{tksvd,
author={E. M. Eksioglu and O. Bayir},
journal={IEEE Signal Processing Letters},
title={K-SVD Meets Transform Learning: Transform K-SVD},
year={2014},
volume={21},
number={3},
pages={347-351},
keywords={encoding;image denoising;signal representation;singular value decomposition;transforms;analysis K-SVD;analysis dictionary learning;analysis operator learning;analysis sparsity models;sparse coding;sparse signal representation;transform K-SVD;transform operator learning algorithm;Algorithm design and analysis;Analytical models;Dictionaries;Minimization;Signal processing algorithms;Transforms;Vectors;Analysis operator learning;dictionary learning;sparse representation;sparsifying transform learning},
doi={10.1109/LSP.2014.2303076},
ISSN={1070-9908},
month={March},}

@INPROCEEDINGS{fksvd,
author={Q. Zhang and B. Li},
booktitle={Computer Vision and Pattern Recognition (CVPR), 2010 IEEE Conference on},
title={Discriminative K-SVD for dictionary learning in face recognition},
year={2010},
pages={2691-2698},
keywords={face recognition;learning (artificial intelligence);optimisation;pattern classification;AR database;D-KSVD;YaleB database;dictionary learning;discriminative K-SVD;linear classifier;optimization;over complete dictionary;sparse representation based face recognition;Computer vision;Databases;Dictionaries;Face detection;Face recognition;Feature extraction;Image coding;Image recognition;Iterative algorithms;Optimization methods},
doi={10.1109/CVPR.2010.5539989},
ISSN={1063-6919},
month={June},}

extension: bib